home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume18 / rmtlib2 < prev    next >
Encoding:
Internet Message Format  |  1989-04-19  |  24.9 KB
  1. Subject:  v18i109:  Remote tape library
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: arnold@emoryu1.cc.emory.edu (Arnold D. Robbins)
  7. Posting-number: Volume 18, Issue 109
  8. Archive-name: rmtlib2
  9.  
  10. [  Needs for for non-BSD-dervied systems.   --r$  ]
  11.  
  12. This is the remote mag tape library. It allows a program that uses
  13. Unix system calls to transparently use a file (usually a tape drive) on
  14. another system via /etc/rmt, simply by including <rmt.h>.  It is
  15. particularly useful with tar and dd, and is supplied with GNU tar.
  16.  
  17. This package has evolved somewhat over the years.  My thanks to the
  18. people who did most of the original work, and those who've contributed
  19. bug fixes; appropriate credit is in the man page and source files.
  20.  
  21. Enjoy,
  22.  
  23. Arnold Robbins
  24. Emory U. Computing Center
  25. arnold@emoryu1.cc.emory.edu
  26. gatech!emoryu1!arnold
  27.  
  28. ----------------------------------------
  29. #! /bin/sh
  30. # This is a shell archive, meaning:
  31. # 1. Remove everything above the #! /bin/sh line.
  32. # 2. Save the resulting text in a file.
  33. # 3. Execute the file with /bin/sh (not csh) to create:
  34. #    README
  35. #    Makefile
  36. #    rmt.h
  37. #    rmtlib.c
  38. #    rmtops.3
  39. export PATH; PATH=/bin:/usr/bin:$PATH
  40. echo shar: "extracting 'README'" '(602 characters)'
  41. if test -f 'README'
  42. then
  43.     echo shar: "will not over-write existing file 'README'"
  44. else
  45. cat << \SHAR_EOF > 'README'
  46. README
  47.  
  48. This is the remote mag tape library. It allows a program that uses
  49. Unix system calls to transparently use a file (usually a tape drive) on
  50. another system via /etc/rmt, simply by including <rmt.h>.  It is
  51. particularly useful with tar and dd, and is supplied with GNU tar.
  52.  
  53. This package has evolved somewhat over the years.  My thanks to the
  54. people who did most of the original work, and those who've contributed
  55. bug fixes; appropriate credit is in the man page and source files.
  56.  
  57. Enjoy,
  58.  
  59. Arnold Robbins
  60. Emory U. Computing Center
  61. arnold@emoryu1.cc.emory.edu
  62. gatech!emoryu1!arnold
  63. +1 404 727 7636
  64. SHAR_EOF
  65. fi
  66. echo shar: "extracting 'Makefile'" '(421 characters)'
  67. if test -f 'Makefile'
  68. then
  69.     echo shar: "will not over-write existing file 'Makefile'"
  70. else
  71. cat << \SHAR_EOF > 'Makefile'
  72. #
  73. # $Header: Makefile,v 1.1 86/10/09 16:42:13 root Locked $
  74. #
  75. # $Log:    Makefile,v $
  76. # Revision 1.1  86/10/09  16:42:13  root
  77. # Initial revision
  78. # 
  79. #
  80. # Makefile for rmtlib
  81.  
  82. CFLAGS= -O
  83. SRC= rmtlib.c
  84. DOC= rmtops.3
  85.  
  86. MANSEC=3
  87. DEST= /usr/lib
  88.  
  89. librmt.a: rmtlib.o
  90.     ar rv librmt.a rmtlib.o
  91.  
  92. install: librmt.a
  93.     cp librmt.a /usr/lib
  94.     ranlib /usr/lib/librmt.a
  95.     cp $(DOC) /usr/man/man$(MANSEC)/rmtops.$(MANSEC)
  96.  
  97. clean:
  98.     rm -f rmtlib.o
  99. SHAR_EOF
  100. fi
  101. echo shar: "extracting 'rmt.h'" '(1056 characters)'
  102. if test -f 'rmt.h'
  103. then
  104.     echo shar: "will not over-write existing file 'rmt.h'"
  105. else
  106. cat << \SHAR_EOF > 'rmt.h'
  107. /*
  108.  * $Header: rmt.h,v 1.1 86/10/09 16:17:20 root Locked $
  109.  *
  110.  * $Log:    rmt.h,v $
  111.  * Revision 1.1  86/10/09  16:17:20  root
  112.  * Initial revision
  113.  * 
  114.  */
  115.  
  116. /*
  117.  *    rmt.h
  118.  *
  119.  *    Added routines to replace open(), close(), lseek(), ioctl(), etc.
  120.  *    The preprocessor can be used to remap these the rmtopen(), etc
  121.  *    thus minimizing source changes.
  122.  *
  123.  *    This file must be included before <sys/stat.h>, since it redefines
  124.  *    stat to be rmtstat, so that struct stat xyzzy; declarations work
  125.  *    properly.
  126.  *
  127.  *    -- Fred Fish (w/some changes by Arnold Robbins)
  128.  */
  129.  
  130.  
  131. #ifndef access        /* avoid multiple redefinition */
  132. #ifndef lint        /* in this case what lint doesn't know won't hurt it */
  133. #define access rmtaccess
  134. #define close rmtclose
  135. #define creat rmtcreat
  136. #define dup rmtdup
  137. #define fcntl rmtfcntl
  138. #define fstat rmtfstat
  139. #define ioctl rmtioctl
  140. #define isatty rmtisatty
  141. #define lseek rmtlseek
  142. #define lstat rmtlstat
  143. #define open rmtopen
  144. #define read rmtread
  145. #define stat rmtstat
  146. #define write rmtwrite
  147.  
  148. extern long rmtlseek ();    /* all the rest are int's */
  149. #endif
  150. #endif
  151. SHAR_EOF
  152. fi
  153. echo shar: "extracting 'rmtlib.c'" '(16015 characters)'
  154. if test -f 'rmtlib.c'
  155. then
  156.     echo shar: "will not over-write existing file 'rmtlib.c'"
  157. else
  158. cat << \SHAR_EOF > 'rmtlib.c'
  159. #ifndef lint
  160. static char *RCSid = "$Header: /usr/src/local/usr.lib/librmt/RCS/rmtlib.c,v 1.7 89/03/23 14:09:51 root Exp Locker: root $";
  161. #endif
  162.  
  163. /*
  164.  * $Log:    rmtlib.c,v $
  165.  * Revision 1.7  89/03/23  14:09:51  root
  166.  * Fix from haynes@ucscc.ucsc.edu for use w/compat. ADR.
  167.  * 
  168.  * Revision 1.6  88/10/25  17:04:29  root
  169.  * rexec code and a bug fix from srs!dan, miscellanious cleanup. ADR.
  170.  * 
  171.  * Revision 1.5  88/10/25  16:30:17  root
  172.  * Fix from jeff@gatech.edu for getting user@host:dev right. ADR.
  173.  * 
  174.  * Revision 1.4  87/10/30  10:36:12  root
  175.  * Made 4.2 syntax a compile time option. ADR.
  176.  * 
  177.  * Revision 1.3  87/04/22  11:16:48  root
  178.  * Two fixes from parmelee@wayback.cs.cornell.edu to correctly
  179.  * do fd biasing and rmt protocol on 'S' command. ADR.
  180.  * 
  181.  * Revision 1.2  86/10/09  16:38:53  root
  182.  * Changed to reflect 4.3BSD rcp syntax. ADR.
  183.  * 
  184.  * Revision 1.1  86/10/09  16:17:35  root
  185.  * Initial revision
  186.  * 
  187.  */
  188.  
  189. /*
  190.  *    rmt --- remote tape emulator subroutines
  191.  *
  192.  *    Originally written by Jeff Lee, modified some by Arnold Robbins
  193.  *
  194.  *    WARNING:  The man page rmt(8) for /etc/rmt documents the remote mag
  195.  *    tape protocol which rdump and rrestore use.  Unfortunately, the man
  196.  *    page is *WRONG*.  The author of the routines I'm including originally
  197.  *    wrote his code just based on the man page, and it didn't work, so he
  198.  *    went to the rdump source to figure out why.  The only thing he had to
  199.  *    change was to check for the 'F' return code in addition to the 'E',
  200.  *    and to separate the various arguments with \n instead of a space.  I
  201.  *    personally don't think that this is much of a problem, but I wanted to
  202.  *    point it out.
  203.  *    -- Arnold Robbins
  204.  *
  205.  *    Redone as a library that can replace open, read, write, etc, by
  206.  *    Fred Fish, with some additional work by Arnold Robbins.
  207.  */
  208.  
  209. /*
  210.  *    MAXUNIT --- Maximum number of remote tape file units
  211.  *
  212.  *    READ --- Return the number of the read side file descriptor
  213.  *    WRITE --- Return the number of the write side file descriptor
  214.  */
  215.  
  216. #define RMTIOCTL    1
  217. /* #define USE_REXEC    1    /* rexec code courtesy of Dan Kegel, srs!dan */
  218.  
  219. #include <stdio.h>
  220. #include <signal.h>
  221. #include <sys/types.h>
  222.  
  223. #ifdef RMTIOCTL
  224. #include <sys/ioctl.h>
  225. #include <sys/mtio.h>
  226. #endif
  227.  
  228. #ifdef USE_REXEC
  229. #include <netdb.h>
  230. #endif
  231.  
  232. #include <errno.h>
  233. #include <setjmp.h>
  234. #include <sys/stat.h>
  235.  
  236. #define BUFMAGIC    64    /* a magic number for buffer sizes */
  237. #define MAXUNIT    4
  238.  
  239. #define READ(fd)    (Ctp[fd][0])
  240. #define WRITE(fd)    (Ptc[fd][1])
  241.  
  242. static int Ctp[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  243. static int Ptc[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  244.  
  245. static jmp_buf Jmpbuf;
  246. extern int errno;
  247.  
  248. /*
  249.  *    abort --- close off a remote tape connection
  250.  */
  251.  
  252. static void abort(fildes)
  253. int fildes;
  254. {
  255.     close(READ(fildes));
  256.     close(WRITE(fildes));
  257.     READ(fildes) = -1;
  258.     WRITE(fildes) = -1;
  259. }
  260.  
  261.  
  262.  
  263. /*
  264.  *    command --- attempt to perform a remote tape command
  265.  */
  266.  
  267. static int command(fildes, buf)
  268. int fildes;
  269. char *buf;
  270. {
  271.     register int blen;
  272.     int (*pstat)();
  273.  
  274. /*
  275.  *    save current pipe status and try to make the request
  276.  */
  277.  
  278.     blen = strlen(buf);
  279.     pstat = signal(SIGPIPE, SIG_IGN);
  280.     if (write(WRITE(fildes), buf, blen) == blen)
  281.     {
  282.         signal(SIGPIPE, pstat);
  283.         return(0);
  284.     }
  285.  
  286. /*
  287.  *    something went wrong. close down and go home
  288.  */
  289.  
  290.     signal(SIGPIPE, pstat);
  291.     abort(fildes);
  292.  
  293.     errno = EIO;
  294.     return(-1);
  295. }
  296.  
  297.  
  298.  
  299. /*
  300.  *    status --- retrieve the status from the pipe
  301.  */
  302.  
  303. static int status(fildes)
  304. int fildes;
  305. {
  306.     int i;
  307.     char c, *cp;
  308.     char buffer[BUFMAGIC];
  309.  
  310. /*
  311.  *    read the reply command line
  312.  */
  313.  
  314.     for (i = 0, cp = buffer; i < BUFMAGIC; i++, cp++)
  315.     {
  316.         if (read(READ(fildes), cp, 1) != 1)
  317.         {
  318.             abort(fildes);
  319.             errno = EIO;
  320.             return(-1);
  321.         }
  322.         if (*cp == '\n')
  323.         {
  324.             *cp = 0;
  325.             break;
  326.         }
  327.     }
  328.  
  329.     if (i == BUFMAGIC)
  330.     {
  331.         abort(fildes);
  332.         errno = EIO;
  333.         return(-1);
  334.     }
  335.  
  336. /*
  337.  *    check the return status
  338.  */
  339.  
  340.     for (cp = buffer; *cp; cp++)
  341.         if (*cp != ' ')
  342.             break;
  343.  
  344.     if (*cp == 'E' || *cp == 'F')
  345.     {
  346.         errno = atoi(cp + 1);
  347.         while (read(READ(fildes), &c, 1) == 1)
  348.             if (c == '\n')
  349.                 break;
  350.  
  351.         if (*cp == 'F')
  352.             abort(fildes);
  353.  
  354.         return(-1);
  355.     }
  356.  
  357. /*
  358.  *    check for mis-synced pipes
  359.  */
  360.  
  361.     if (*cp != 'A')
  362.     {
  363.         abort(fildes);
  364.         errno = EIO;
  365.         return(-1);
  366.     }
  367.  
  368.     return(atoi(cp + 1));
  369. }
  370.  
  371. #ifdef USE_REXEC
  372.  
  373. /*
  374.  * _rmt_rexec
  375.  *
  376.  * execute /etc/rmt on a remote system using rexec().
  377.  * Return file descriptor of bidirectional socket for stdin and stdout
  378.  * If username is NULL, or an empty string, uses current username.
  379.  *
  380.  * ADR: By default, this code is not used, since it requires that
  381.  * the user have a .netrc file in his/her home directory, or that the
  382.  * application designer be willing to have rexec prompt for login and
  383.  * password info. This may be unacceptable, and .rhosts files for use
  384.  * with rsh are much more common on BSD systems.
  385.  */
  386.  
  387. static int
  388. _rmt_rexec(host, user)
  389. char *host;
  390. char *user;        /* may be NULL */
  391. {
  392.     struct servent *rexecserv;
  393.  
  394.     rexecserv = getservbyname("exec", "tcp");
  395.     if (NULL == rexecserv) {
  396.         fprintf (stderr, "? exec/tcp: service not available.");
  397.         exit (-1);
  398.     }
  399.     if ((user != NULL) && *user == '\0')
  400.         user = (char *) NULL;
  401.     return rexec (&host, rexecserv->s_port, user, NULL,
  402.             "/etc/rmt", (int *)NULL);
  403. }
  404. #endif /* USE_REXEC */
  405.  
  406. /*
  407.  *    _rmt_open --- open a magtape device on system specified, as given user
  408.  *
  409.  *    file name has the form [user@]system:/dev/????
  410. #ifdef COMPAT
  411.  *    file name has the form system[.user]:/dev/????
  412. #endif
  413.  */
  414.  
  415. #define MAXHOSTLEN    257    /* BSD allows very long host names... */
  416.  
  417. static int _rmt_open (path, oflag, mode)
  418. char *path;
  419. int oflag;
  420. int mode;
  421. {
  422.     int i, rc;
  423.     char buffer[BUFMAGIC];
  424.     char system[MAXHOSTLEN];
  425.     char device[BUFMAGIC];
  426.     char login[BUFMAGIC];
  427.     char *sys, *dev, *user;
  428.  
  429.     sys = system;
  430.     dev = device;
  431.     user = login;
  432.  
  433. /*
  434.  *    first, find an open pair of file descriptors
  435.  */
  436.  
  437.     for (i = 0; i < MAXUNIT; i++)
  438.         if (READ(i) == -1 && WRITE(i) == -1)
  439.             break;
  440.  
  441.     if (i == MAXUNIT)
  442.     {
  443.         errno = EMFILE;
  444.         return(-1);
  445.     }
  446.  
  447. /*
  448.  *    pull apart system and device, and optional user
  449.  *    don't munge original string
  450.  *    if COMPAT is defined, also handle old (4.2) style person.site notation.
  451.  */
  452.  
  453.     while (*path != '@'
  454. #ifdef COMPAT
  455.             && *path != '.'
  456. #endif
  457.             && *path != ':') {
  458.         *sys++ = *path++;
  459.     }
  460.     *sys = '\0';
  461.     path++;
  462.  
  463.     if (*(path - 1) == '@')
  464.     {
  465.         (void) strcpy (user, system);    /* saw user part of user@host */
  466.         sys = system;            /* start over */
  467.         while (*path != ':') {
  468.             *sys++ = *path++;
  469.         }
  470.         *sys = '\0';
  471.         path++;
  472.     }
  473. #ifdef COMPAT
  474.     else if (*(path - 1) == '.')
  475.     {
  476.         while (*path != ':') {
  477.             *user++ = *path++;
  478.         }
  479.         *user = '\0';
  480.         path++;
  481.     }
  482. #endif
  483.     else
  484.         *user = '\0';
  485.  
  486.     while (*path) {
  487.         *dev++ = *path++;
  488.     }
  489.     *dev = '\0';
  490.  
  491. #ifdef USE_REXEC
  492. /* 
  493.  *    Execute the remote command using rexec 
  494.  */
  495.     READ(i) = WRITE(i) = _rmt_rexec(system, login);
  496.     if (READ(i) < 0)
  497.         return -1;
  498. #else
  499. /*
  500.  *    setup the pipes for the 'rsh' command and fork
  501.  */
  502.  
  503.     if (pipe(Ptc[i]) == -1 || pipe(Ctp[i]) == -1)
  504.         return(-1);
  505.  
  506.     if ((rc = fork()) == -1)
  507.         return(-1);
  508.  
  509.     if (rc == 0)
  510.     {
  511.         close(0);
  512.         dup(Ptc[i][0]);
  513.         close(Ptc[i][0]); close(Ptc[i][1]);
  514.         close(1);
  515.         dup(Ctp[i][1]);
  516.         close(Ctp[i][0]); close(Ctp[i][1]);
  517.         (void) setuid (getuid ());
  518.         (void) setgid (getgid ());
  519.         if (*login)
  520.         {
  521.             execl("/usr/ucb/rsh", "rsh", system, "-l", login,
  522.                 "/etc/rmt", (char *) 0);
  523.             execl("/usr/bin/remsh", "remsh", system, "-l", login,
  524.                 "/etc/rmt", (char *) 0);
  525.         }
  526.         else
  527.         {
  528.             execl("/usr/ucb/rsh", "rsh", system,
  529.                 "/etc/rmt", (char *) 0);
  530.             execl("/usr/bin/remsh", "remsh", system,
  531.                 "/etc/rmt", (char *) 0);
  532.         }
  533.  
  534. /*
  535.  *    bad problems if we get here
  536.  */
  537.  
  538.         perror("exec");
  539.         exit(1);
  540.     }
  541.  
  542.     close(Ptc[i][0]); close(Ctp[i][1]);
  543. #endif
  544.  
  545. /*
  546.  *    now attempt to open the tape device
  547.  */
  548.  
  549.     sprintf(buffer, "O%s\n%d\n", device, oflag);
  550.     if (command(i, buffer) == -1 || status(i) == -1)
  551.         return(-1);
  552.  
  553.     return(i);
  554. }
  555.  
  556.  
  557.  
  558. /*
  559.  *    _rmt_close --- close a remote magtape unit and shut down
  560.  */
  561.  
  562. static int _rmt_close(fildes)
  563. int fildes;
  564. {
  565.     int rc;
  566.  
  567.     if (command(fildes, "C\n") != -1)
  568.     {
  569.         rc = status(fildes);
  570.  
  571.         abort(fildes);
  572.         return(rc);
  573.     }
  574.  
  575.     return(-1);
  576. }
  577.  
  578.  
  579.  
  580. /*
  581.  *    _rmt_read --- read a buffer from a remote tape
  582.  */
  583.  
  584. static int _rmt_read(fildes, buf, nbyte)
  585. int fildes;
  586. char *buf;
  587. unsigned int nbyte;
  588. {
  589.     int rc, i;
  590.     char buffer[BUFMAGIC];
  591.  
  592.     sprintf(buffer, "R%d\n", nbyte);
  593.     if (command(fildes, buffer) == -1 || (rc = status(fildes)) == -1)
  594.         return(-1);
  595.  
  596.     for (i = 0; i < rc; i += nbyte, buf += nbyte)
  597.     {
  598.         nbyte = read(READ(fildes), buf, rc);
  599.         if (nbyte <= 0)
  600.         {
  601.             abort(fildes);
  602.             errno = EIO;
  603.             return(-1);
  604.         }
  605.     }
  606.  
  607.     return(rc);
  608. }
  609.  
  610.  
  611.  
  612. /*
  613.  *    _rmt_write --- write a buffer to the remote tape
  614.  */
  615.  
  616. static int _rmt_write(fildes, buf, nbyte)
  617. int fildes;
  618. char *buf;
  619. unsigned int nbyte;
  620. {
  621.     int rc;
  622.     char buffer[BUFMAGIC];
  623.     int (*pstat)();
  624.  
  625.     sprintf(buffer, "W%d\n", nbyte);
  626.     if (command(fildes, buffer) == -1)
  627.         return(-1);
  628.  
  629.     pstat = signal(SIGPIPE, SIG_IGN);
  630.     if (write(WRITE(fildes), buf, nbyte) == nbyte)
  631.     {
  632.         signal (SIGPIPE, pstat);
  633.         return(status(fildes));
  634.     }
  635.  
  636.     signal (SIGPIPE, pstat);
  637.     abort(fildes);
  638.     errno = EIO;
  639.     return(-1);
  640. }
  641.  
  642.  
  643.  
  644. /*
  645.  *    _rmt_lseek --- perform an imitation lseek operation remotely
  646.  */
  647.  
  648. static long _rmt_lseek(fildes, offset, whence)
  649. int fildes;
  650. long offset;
  651. int whence;
  652. {
  653.     char buffer[BUFMAGIC];
  654.  
  655.     sprintf(buffer, "L%d\n%d\n", offset, whence);
  656.     if (command(fildes, buffer) == -1)
  657.         return(-1);
  658.  
  659.     return(status(fildes));
  660. }
  661.  
  662.  
  663. /*
  664.  *    _rmt_ioctl --- perform raw tape operations remotely
  665.  */
  666.  
  667. #ifdef RMTIOCTL
  668. static _rmt_ioctl(fildes, op, arg)
  669. int fildes, op;
  670. char *arg;
  671. {
  672.     char c;
  673.     int rc, cnt;
  674.     char buffer[BUFMAGIC];
  675.  
  676. /*
  677.  *    MTIOCOP is the easy one. nothing is transfered in binary
  678.  */
  679.  
  680.     if (op == MTIOCTOP)
  681.     {
  682.         sprintf(buffer, "I%d\n%d\n", ((struct mtop *) arg)->mt_op,
  683.             ((struct mtop *) arg)->mt_count);
  684.         if (command(fildes, buffer) == -1)
  685.             return(-1);
  686.         return(status(fildes));
  687.     }
  688.  
  689. /*
  690.  *    we can only handle 2 ops, if not the other one, punt
  691.  */
  692.  
  693.     if (op != MTIOCGET)
  694.     {
  695.         errno = EINVAL;
  696.         return(-1);
  697.     }
  698.  
  699. /*
  700.  *    grab the status and read it directly into the structure
  701.  *    this assumes that the status buffer is (hopefully) not
  702.  *    padded and that 2 shorts fit in a long without any word
  703.  *    alignment problems, ie - the whole struct is contiguous
  704.  *    NOTE - this is probably NOT a good assumption.
  705.  */
  706.  
  707.     if (command(fildes, "S") == -1 || (rc = status(fildes)) == -1)
  708.         return(-1);
  709.  
  710.     for (; rc > 0; rc -= cnt, arg += cnt)
  711.     {
  712.         cnt = read(READ(fildes), arg, rc);
  713.         if (cnt <= 0)
  714.         {
  715.             abort(fildes);
  716.             errno = EIO;
  717.             return(-1);
  718.         }
  719.     }
  720.  
  721. /*
  722.  *    now we check for byte position. mt_type is a small integer field
  723.  *    (normally) so we will check its magnitude. if it is larger than
  724.  *    256, we will assume that the bytes are swapped and go through
  725.  *    and reverse all the bytes
  726.  */
  727.  
  728.     if (((struct mtget *) arg)->mt_type < 256)
  729.         return(0);
  730.  
  731.     for (cnt = 0; cnt < rc; cnt += 2)
  732.     {
  733.         c = arg[cnt];
  734.         arg[cnt] = arg[cnt+1];
  735.         arg[cnt+1] = c;
  736.     }
  737.  
  738.     return(0);
  739.   }
  740. #endif /* RMTIOCTL */
  741.  
  742. /*
  743.  *    Added routines to replace open(), close(), lseek(), ioctl(), etc.
  744.  *    The preprocessor can be used to remap these the rmtopen(), etc
  745.  *    thus minimizing source changes:
  746.  *
  747.  *        #ifdef <something>
  748.  *        #  define access rmtaccess
  749.  *        #  define close rmtclose
  750.  *        #  define creat rmtcreat
  751.  *        #  define dup rmtdup
  752.  *        #  define fcntl rmtfcntl
  753.  *        #  define fstat rmtfstat
  754.  *        #  define ioctl rmtioctl
  755.  *        #  define isatty rmtisatty
  756.  *        #  define lseek rmtlseek
  757.  *        #  define lstat rmtlstat
  758.  *        #  define open rmtopen
  759.  *        #  define read rmtread
  760.  *        #  define stat rmtstat
  761.  *        #  define write rmtwrite
  762.  *        #endif
  763.  *
  764.  *    -- Fred Fish
  765.  *
  766.  *    ADR --- I set up a <rmt.h> include file for this
  767.  *
  768.  */
  769.  
  770. /*
  771.  *    Note that local vs remote file descriptors are distinquished
  772.  *    by adding a bias to the remote descriptors.  This is a quick
  773.  *    and dirty trick that may not be portable to some systems.
  774.  */
  775.  
  776. #define REM_BIAS 128
  777.  
  778.  
  779. /*
  780.  *    Test pathname to see if it is local or remote.  A remote device
  781.  *    is any string that contains ":/dev/".  Returns 1 if remote,
  782.  *    0 otherwise.
  783.  */
  784.  
  785. static int remdev (path)
  786. register char *path;
  787. {
  788. #define strchr    index
  789.     extern char *strchr ();
  790.  
  791.     if ((path = strchr (path, ':')) != NULL)
  792.     {
  793.         if (strncmp (path + 1, "/dev/", 5) == 0)
  794.         {
  795.             return (1);
  796.         }
  797.     }
  798.     return (0);
  799. }
  800.  
  801.  
  802. /*
  803.  *    Open a local or remote file.  Looks just like open(2) to
  804.  *    caller.
  805.  */
  806.  
  807. int rmtopen (path, oflag, mode)
  808. char *path;
  809. int oflag;
  810. int mode;
  811. {
  812.     int fd;
  813.  
  814.     if (remdev (path))
  815.     {
  816.         fd = _rmt_open (path, oflag, mode);
  817.  
  818.         return (fd == -1) ? -1 : (fd + REM_BIAS);
  819.     }
  820.     else
  821.     {
  822.         return (open (path, oflag, mode));
  823.     }
  824. }
  825.  
  826. /*
  827.  *    Test pathname for specified access.  Looks just like access(2)
  828.  *    to caller.
  829.  */
  830.  
  831. int rmtaccess (path, amode)
  832. char *path;
  833. int amode;
  834. {
  835.     if (remdev (path))
  836.     {
  837.         return (0);        /* Let /etc/rmt find out */
  838.     }
  839.     else
  840.     {
  841.         return (access (path, amode));
  842.     }
  843. }
  844.  
  845.  
  846. /*
  847.  *    Read from stream.  Looks just like read(2) to caller.
  848.  */
  849.   
  850. int rmtread (fildes, buf, nbyte)
  851. int fildes;
  852. char *buf;
  853. unsigned int nbyte;
  854. {
  855.     if (isrmt (fildes))
  856.     {
  857.         return (_rmt_read (fildes - REM_BIAS, buf, nbyte));
  858.     }
  859.     else
  860.     {
  861.         return (read (fildes, buf, nbyte));
  862.     }
  863. }
  864.  
  865.  
  866. /*
  867.  *    Write to stream.  Looks just like write(2) to caller.
  868.  */
  869.  
  870. int rmtwrite (fildes, buf, nbyte)
  871. int fildes;
  872. char *buf;
  873. unsigned int nbyte;
  874. {
  875.     if (isrmt (fildes))
  876.     {
  877.         return (_rmt_write (fildes - REM_BIAS, buf, nbyte));
  878.     }
  879.     else
  880.     {
  881.         return (write (fildes, buf, nbyte));
  882.     }
  883. }
  884.  
  885. /*
  886.  *    Perform lseek on file.  Looks just like lseek(2) to caller.
  887.  */
  888.  
  889. long rmtlseek (fildes, offset, whence)
  890. int fildes;
  891. long offset;
  892. int whence;
  893. {
  894.     if (isrmt (fildes))
  895.     {
  896.         return (_rmt_lseek (fildes - REM_BIAS, offset, whence));
  897.     }
  898.     else
  899.     {
  900.         return (lseek (fildes, offset, whence));
  901.     }
  902. }
  903.  
  904.  
  905. /*
  906.  *    Close a file.  Looks just like close(2) to caller.
  907.  */
  908.  
  909. int rmtclose (fildes)
  910. int fildes;
  911. {
  912.     if (isrmt (fildes))
  913.     {
  914.         return (_rmt_close (fildes - REM_BIAS));
  915.     }
  916.     else
  917.     {
  918.         return (close (fildes));
  919.     }
  920. }
  921.  
  922. /*
  923.  *    Do ioctl on file.  Looks just like ioctl(2) to caller.
  924.  */
  925.  
  926. int rmtioctl (fildes, request, arg)
  927. int fildes;
  928. unsigned long request;
  929. char *arg;
  930. {
  931.     if (isrmt (fildes))
  932.     {
  933. #ifdef RMTIOCTL
  934.         return (_rmt_ioctl (fildes - REM_BIAS, request, arg));
  935. #else
  936.         errno = EOPNOTSUPP;
  937.         return (-1);        /* For now  (fnf) */
  938. #endif
  939.     }
  940.     else
  941.     {
  942.         return (ioctl (fildes, request, arg));
  943.     }
  944. }
  945.  
  946.  
  947. /*
  948.  *    Duplicate an open file descriptor.  Looks just like dup(2)
  949.  *    to caller.
  950.  */
  951.  
  952. int rmtdup (fildes)
  953. int fildes;
  954. {
  955.     if (isrmt (fildes))
  956.     {
  957.         errno = EOPNOTSUPP;
  958.         return (-1);        /* For now (fnf) */
  959.     }
  960.     else
  961.     {
  962.         return (dup (fildes));
  963.     }
  964. }
  965.  
  966. /*
  967.  *    Get file status.  Looks just like fstat(2) to caller.
  968.  */
  969.  
  970. int rmtfstat (fildes, buf)
  971. int fildes;
  972. struct stat *buf;
  973. {
  974.     if (isrmt (fildes))
  975.     {
  976.         errno = EOPNOTSUPP;
  977.         return (-1);        /* For now (fnf) */
  978.     }
  979.     else
  980.     {
  981.         return (fstat (fildes, buf));
  982.     }
  983. }
  984.  
  985.  
  986. /*
  987.  *    Get file status.  Looks just like stat(2) to caller.
  988.  */
  989.  
  990. int rmtstat (path, buf)
  991. char *path;
  992. struct stat *buf;
  993. {
  994.     if (remdev (path))
  995.     {
  996.         errno = EOPNOTSUPP;
  997.         return (-1);        /* For now (fnf) */
  998.     }
  999.     else
  1000.     {
  1001.         return (stat (path, buf));
  1002.     }
  1003. }
  1004.  
  1005.  
  1006.  
  1007. /*
  1008.  *    Create a file from scratch.  Looks just like creat(2) to the caller.
  1009.  */
  1010.  
  1011. #include <sys/file.h>        /* BSD DEPENDANT!!! */
  1012. /* #include <fcntl.h>        /* use this one for S5 with remote stuff */
  1013.  
  1014. int rmtcreat (path, mode)
  1015. char *path;
  1016. int mode;
  1017. {
  1018.     if (remdev (path))
  1019.     {
  1020.         return (rmtopen (path, 1 | O_CREAT, mode));
  1021.     }
  1022.     else
  1023.     {
  1024.         return (creat (path, mode));
  1025.     }
  1026. }
  1027.  
  1028. /*
  1029.  *    Isrmt. Let a programmer know he has a remote device.
  1030.  */
  1031.  
  1032. int isrmt (fd)
  1033. int fd;
  1034. {
  1035.     return (fd >= REM_BIAS);
  1036. }
  1037.  
  1038. /*
  1039.  *    Rmtfcntl. Do a remote fcntl operation.
  1040.  */
  1041.  
  1042. int rmtfcntl (fd, cmd, arg)
  1043. int fd, cmd, arg;
  1044. {
  1045.     if (isrmt (fd))
  1046.     {
  1047.         errno = EOPNOTSUPP;
  1048.         return (-1);
  1049.     }
  1050.     else
  1051.     {
  1052.         return (fcntl (fd, cmd, arg));
  1053.     }
  1054. }
  1055.  
  1056. /*
  1057.  *    Rmtisatty.  Do the isatty function.
  1058.  */
  1059.  
  1060. int rmtisatty (fd)
  1061. int fd;
  1062. {
  1063.     if (isrmt (fd))
  1064.         return (0);
  1065.     else
  1066.         return (isatty (fd));
  1067. }
  1068.  
  1069.  
  1070. /*
  1071.  *    Get file status, even if symlink.  Looks just like lstat(2) to caller.
  1072.  */
  1073.  
  1074. int rmtlstat (path, buf)
  1075. char *path;
  1076. struct stat *buf;
  1077. {
  1078.     if (remdev (path))
  1079.     {
  1080.         errno = EOPNOTSUPP;
  1081.         return (-1);        /* For now (fnf) */
  1082.     }
  1083.     else
  1084.     {
  1085.         return (lstat (path, buf));
  1086.     }
  1087. }
  1088. SHAR_EOF
  1089. fi
  1090. echo shar: "extracting 'rmtops.3'" '(5300 characters)'
  1091. if test -f 'rmtops.3'
  1092. then
  1093.     echo shar: "will not over-write existing file 'rmtops.3'"
  1094. else
  1095. cat << \SHAR_EOF > 'rmtops.3'
  1096. ...
  1097. ... $Header: rmtops.3,v 1.4 88/10/25 17:05:05 root Locked $
  1098. ... 
  1099. ... $Log:    rmtops.3,v $
  1100. ... Revision 1.4  88/10/25  17:05:05  root
  1101. ... Documented configuration options and added Dan Kegel to AUTHORS. ADR.
  1102. ... 
  1103. ... Revision 1.3  87/10/30  10:36:38  root
  1104. ... Some cleanup. 4.3 syntax is default, 4.2 is a compile time option.
  1105. ... 
  1106. ... Revision 1.2  86/10/09  16:38:02  root
  1107. ... Changed to reflect 4.3BSD rcp syntax and better rmt(8) capabilities. ADR.
  1108. ... 
  1109. ... Revision 1.1  86/10/09  16:18:47  root
  1110. ... Initial revision
  1111. ... 
  1112. ...
  1113. .TH RMTOPS 3 local
  1114. .SH NAME
  1115. rmtops \- access tape drives on remote machines
  1116. .SH SYNOPSIS
  1117. .nf
  1118. .ft B
  1119. #include <rmt.h>
  1120. #include <sys/stat.h>    /* MUST come after <rmt.h> */
  1121.  
  1122. int isrmt (fd)
  1123. int fd;
  1124.  
  1125. int rmtaccess (file, mode)
  1126. char *file;
  1127. int mode;
  1128.  
  1129. int rmtclose (fd)
  1130. int fd;
  1131.  
  1132. int rmtcreat (file, mode)
  1133. char *file;
  1134. int mode;
  1135.  
  1136. int rmtdup (fd)
  1137. int fd;
  1138.  
  1139. int rmtfcntl (fd, cmd, arg)
  1140. int fd, cmd, arg;
  1141.  
  1142. int rmtfstat (fd, buf)
  1143. int fd;
  1144. struct stat *buf;
  1145.  
  1146. int rmtioctl (fd, request, argp)
  1147. int fd, request;
  1148. char *argp;
  1149.  
  1150. int rmtisatty (fd)
  1151. int fd;
  1152.  
  1153. long rmtlseek (fd, offset, whence)
  1154. int fd, whence;
  1155. long offset;
  1156.  
  1157. int rmtlstat (file, buf)
  1158. char *file;
  1159. struct stat *buf;
  1160.  
  1161. int rmtopen (file, flags [, mode])
  1162. char *file;
  1163. int flags, mode;
  1164.  
  1165. int rmtread (fd, buf, nbytes)
  1166. int fd, nbytes;
  1167. char *buf;
  1168.  
  1169. int rmtstat (file, buf)
  1170. char *file;
  1171. struct stat *buf;
  1172.  
  1173. int rmtwrite (fd, buf, nbytes)
  1174. int fd, nbytes;
  1175. char *buf;
  1176. .fi
  1177. .ft R
  1178. .SH DESCRIPTION
  1179. .I Rmtops
  1180. provides a simple means of transparently accessing tape drives
  1181. on remote machines over the ethernet, via
  1182. .IR rsh (1)
  1183. and
  1184. .IR rmt (8).
  1185. These routines are used like their corresponding
  1186. system calls, but allow the user to open up a tape drive on a remote
  1187. system on which he or she has an account and the appropriate remote
  1188. permissions.
  1189. .PP
  1190. A remote tape drive file name has the form
  1191. .sp
  1192. .RS
  1193. .RI [ user @] system :/dev/???
  1194. .RE
  1195. .sp
  1196. where
  1197. .I system
  1198. is the remote system,
  1199. .I /dev/???
  1200. is the particular drive on the remote system (raw, blocked, rewinding,
  1201. non-rewinding, etc.), and the optional
  1202. .I user
  1203. is the login name to be used on the remote system, if different from
  1204. the current user's login name.
  1205. .PP
  1206. The library source code may be optionally compiled to recognize the
  1207. old, 4.2 BSD, remote syntax
  1208. .sp
  1209. .RS
  1210. .IR system [. user ]:/dev/???
  1211. .RE
  1212. .sp
  1213. By default, only the first form (introduced in 4.3 BSD) is recognized.
  1214. .PP
  1215. For transparency, the user should include the file
  1216. .IR <rmt.h> ,
  1217. which has the following defines in it:
  1218. .PP
  1219. .nf
  1220. #define access rmtaccess
  1221. #define close rmtclose
  1222. #define creat rmtcreat
  1223. #define dup rmtdup
  1224. #define fcntl rmtfcntl
  1225. #define fstat rmtfstat
  1226. #define ioctl rmtioctl
  1227. #define isatty rmtisatty
  1228. #define lseek rmtlseek
  1229. #define lstat rmtlstat
  1230. #define open rmtopen
  1231. #define read rmtread
  1232. #define stat rmtstat
  1233. #define write rmtwrite
  1234. .fi
  1235. .PP
  1236. This allows the programmer to use
  1237. .IR open ,
  1238. .IR close ,
  1239. .IR read ,
  1240. .IR write ,
  1241. etc. in their normal fashion, with the
  1242. .I rmtops
  1243. routines taking care of differentiating between local and remote files.
  1244. This file should be included
  1245. .I before
  1246. including the file
  1247. .IR <sys/stat.h> ,
  1248. since it redefines the identifier ``stat,'' which is used to declare
  1249. objects of type
  1250. .BR "struct stat" .
  1251. .PP
  1252. The routines differentiate between local and remote file descriptors by
  1253. adding a bias (currently 128) to the file descriptor of the pipe.
  1254. The programmer, if he or she must know if a file is remote, should use the
  1255. .I isrmt
  1256. function.
  1257. .SH FILES
  1258. .TP
  1259. .B /usr/lib/librmt.a
  1260. Contains the remote tape library.  To include the library with a program,
  1261. add the flag
  1262. .B \-lrmt
  1263. to the
  1264. .IR cc (1)
  1265. command line.
  1266. .SH SEE ALSO
  1267. .IR rcp (1),
  1268. .IR rsh (1),
  1269. .IR rmt (8),
  1270. and the appropriate system calls in section 2.
  1271. .SH DIAGNOSTICS
  1272. Several of these routines will return \-1 and set
  1273. .I errno
  1274. to EOPNOTSUPP, if they are given a remote file name or a file descriptor
  1275. on an open remote file (e.g.,
  1276. .IR rmtdup ).
  1277. .SH BUGS
  1278. See \s-1DIAGNOSTICS\s+1 above.  It is to be hoped that true remote file systems
  1279. will eventually appear, and eliminate the need for these routines.
  1280. .PP
  1281. There is no way to use remote tape drives with the
  1282. .IR stdio (3)
  1283. package, short of recompiling it entirely to use these routines.
  1284. .PP
  1285. The
  1286. .IR rmt (8)
  1287. protocol is not very capable.  In particular, it relies on
  1288. TCP/IP sockets for error free transmission, and does no data validation
  1289. of its own.
  1290. .SH CONFIGURATION OPTIONS
  1291. The library may be compiled to allow the use of 4.2 BSD style remote
  1292. file names. This is not recommended.
  1293. .PP
  1294. By default, the library opens two pipes to
  1295. .IR rsh (1).
  1296. It may optionally be compiled to use
  1297. .IR rexec (3),
  1298. instead. Doing so requires the use of a
  1299. .I .netrc
  1300. file in the user's home directory, or that the application designer
  1301. be willing to have
  1302. .I rexec
  1303. prompt the user for a login name and password on the remote host.
  1304. .SH AUTHORS
  1305. Jeff Lee (gatech!jeff) wrote the original routines for accessing
  1306. tape drives via
  1307. .IR rmt (8).
  1308. .PP
  1309. Fred Fish (unisoft!fnf) redid them into a general purpose library.
  1310. .PP
  1311. Arnold Robbins
  1312. (formerly gatech!arnold, now emory!arnold)
  1313. added the ability to specify a user
  1314. name on the remote system, the
  1315. .B <rmt.h>
  1316. include file, this man page,
  1317. cleaned up the library a little,
  1318. and made the appropriate changes for 4.3 BSD.
  1319. .PP
  1320. Dan Kegel (srs!dan) contributed the code to use
  1321. .IR rexec (3)
  1322. library routine.
  1323. SHAR_EOF
  1324. fi
  1325. exit 0
  1326. #    End of shell archive
  1327.  
  1328.